home *** CD-ROM | disk | FTP | other *** search
/ NetNews Offline 2 / NetNews Offline Volume 2.iso / news / comp / lang / c++-part1 / 2648 < prev    next >
Encoding:
Internet Message Format  |  1996-08-06  |  4.3 KB
  1. Path: engnews2.Eng.Sun.COM!usenet
  2. From: nitin@more.eng.sun.com (Nitin More [CONTRACTOR])
  3. Newsgroups: comp.lang.c++
  4. Subject: Re: Multiple Abstract Classes Question
  5. Date: 18 Jan 1996 22:18:13 GMT
  6. Organization: SunSoft
  7. Message-ID: <NITIN.96Jan18141813@more.eng.sun.com>
  8. References: <1996Jan17.160425.6063@ned.cray.com>
  9. NNTP-Posting-Host: more.eng.sun.com
  10. In-reply-to: aztec@cray.com's message of 17 Jan 96 16:04:25 CST
  11.  
  12.  
  13. In article <1996Jan17.160425.6063@ned.cray.com> aztec@cray.com (Joel Garcia-Trevino  {x66457 CF/DEV}) writes:
  14.  
  15. > Newsgroups: comp.lang.c++
  16. > From: aztec@cray.com (Joel Garcia-Trevino  {x66457 CF/DEV})
  17. > Reply-To: aztec@cray.com
  18. > Organization: Cray Research, Inc.
  19. > Date: 17 Jan 96 16:04:25 CST
  20. > 
  21. > 
  22. >  Can I or is it a good idea to have multiple abstract classes to start building
  23. > a class hierarchy?
  24. > 
  25.  
  26. Yes, if you want to keep it flexible.  But if you design your
  27. classes properly, you can still keep them flexible without
  28. having the abstract class defined for your "type" class.  I
  29. don't even see a need for making your "base_net" class
  30. abstract!  I feel the methods get_name() & get_type(), don't
  31. need to be pure virtual at all.  These are accessor methods
  32. and if you keep the attributes they are accessing in the same
  33. class where these methods are defined, they don't need to be
  34. pure virtual methods.  This is how you can change your
  35. classes: 
  36.  
  37. 1.  Move attributes net::name and net::type_pntr to the class
  38.     base_net where the accessors are defined.
  39.  
  40. 2.  Change the accessor methods to return the corresponding
  41.     attribute.  You may not even have to make these methods
  42.     virtual but if you want the derived classes to redefine
  43.     these, you can keep them virtual.
  44.  
  45. 3.  Provide a constructor in the base_net class which takes
  46.     name and type as arguments.  Call this constructor from
  47.     the constructors of the derived class.  Provide default
  48.     values if you want.
  49.  
  50. 4.  Optionally, provide mutator methods to change the
  51.     attributes.  You could even combine the accessors and
  52.     mutators into one by returing a reference to the
  53.     attribute. 
  54.  
  55. 5.  If you still want the base_net class to be abstract (so
  56.     that nobody can instantiate it directly) and if you don't
  57.     have any other pure virtual methods, you can always put
  58.     the constructors for the base_net class in the protected
  59.     section so that only the derived classes can access them.
  60.  
  61. 6.  You may differ until later whether you really need
  62.     abstract class for type.  There won't be lot of changes
  63.     to do that.  So you could start with non-abstract version
  64.     first. 
  65.  
  66.  
  67. By defining the return type of the methods, you have already
  68. decided on the types of the attributes which your derived
  69. classes will have.  Why not then store them in the base class
  70. itself?  
  71.  
  72. Hope this helps.
  73.  
  74. -Nitin
  75.  
  76.  
  77.  
  78.  
  79. >   Example of the base (abstract) classes:
  80. > 
  81. >        class base_type; 
  82. >  
  83. >        class base_net {
  84. >         public:
  85. >          virtual char         *get_name() = 0;    // Gets the name
  86. >          virtual base_type    *get_type() = 0;    // Gets pointer to type
  87. >        };
  88. > 
  89. >        class base_type {
  90. >         public:
  91. >          virtual char *get_type() = 0;            // Gets type name 
  92. >        };
  93. > 
  94. > 
  95. >   The final classes would look something like:
  96. > 
  97. >       class type;
  98. > 
  99. >       class net: public base_net {
  100. >         private:
  101. >          char *name;
  102. >          type *type_pntr;
  103. > 
  104. >         public:
  105. >          char *get_name() { ..... };
  106. >          type *get_type() { ..... }; 
  107. > 
  108. >       };
  109. > 
  110. >      class type: public base_type {
  111. >        private:
  112. >         char *type_name;
  113. > 
  114. >        public:
  115. >         char *get_type() { ..... };
  116. > 
  117. >      };
  118. > 
  119. > 
  120. >  Does it make sense to do it this way?
  121. >         
  122. >  The reason why I want to do this is because there will be different types
  123. > of nets that I will need to work with. I don't know if there will be
  124. > different types of "type" but I thought why not make them all abstract. ???
  125. > 
  126. > 
  127. >  Thanks in advance for your help,
  128. > 
  129. > 
  130. >              Joel Garcia
  131. > 
  132. > 
  133. > 
  134. -- 
  135. ----------------------------------------------------------------------
  136. Nitin More                                                         
  137. SunSoft, Bldg 16  Off: (415) 786 7109                                 
  138. Menlo Park, CA    Fax: (415) 786 7957   e-mail: nitin@more.eng.sun.com
  139. ----------------------------------------------------------------------
  140.